﻿#include <iostream>
#include <assert.h>
using namespace std;

//
//int main()
//{
//	int a[5] = { 1, 2, 3, 4, 5 };
//	int* ptr = (int*)(&a + 1);
//	printf("%d,%d", *(a + 1), *(ptr - 1));
//	return 0;
//}
//struct Test
//{
//	int Num;
//	char* pcName;
//	short sDate;
//	char cha[2];
//	short sBa[4];
//}*p;
//int main()
//{
//	printf("%p\n", p + 0x1);
//	printf("%p\n", (unsigned long)p + 0x1);
//	printf("%p\n", (unsigned int*)p + 0x1);
//	return 0;
//}


//int main()
//{
//	int a[4] = { 1, 2, 3, 4 };
//	int* ptr1 = (int*)(&a + 1);
//	int* ptr2 = (int*)((int)a + 1);
//	printf("%x,%x", ptr1[-1], *ptr2);
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
//	int* p;
//	p = a[0];
//	printf("%d", p[0]);
//	return 0;
//}
//int main()
//{
//	int a[5][5];
//	int(*p)[4];
//	p = a;
//	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
//	return 0;
//}

//int main()
//{
//	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//	int* ptr1 = (int*)(&aa + 1);
//	int* ptr2 = (int*)(*(aa + 1));
//	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
//	return 0;
//}
//
//
//#include <stdio.h>
//int main()
//{
//	char* a[] = { "work","at","alibaba" };
//	char** pa = a;
//	pa++;
//	printf("%s\n", *pa);
//	return 0;
//}



//struct S1
//{
//	double d;
//	char c;
//	int i;
//};
//union Un1
//{
//	char c[5];
//	int i;
//};
//union Un2
//{
//	short c[7];
//	int i;
//};

void* mymemove(void* dst, void* src, size_t count)
{
	void* ret = dst;
	assert(dst);
	assert(src);
	if (src > dst)
	{
		while (count--)
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		char* s1 = (char*)dst;
		char* s2 = (char*)src;
		s1 += count - 1;
		s2 += count - 1;
		while (count--)
		{
			*s1-- = *s2--;
		}
	}
	return ret;
}

void* mymemcpy(void* dst, void* src, size_t count)
{
	void* ret = dst;
	assert(dst);
	assert(src);

	while (count--)
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}

char* mystrstr(const char* str1, const char* str2)
{
	if (!*str2 )
		return (char*)str1;
	char* cp = (char*)str1;
	char* s1, *s2;
	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;
		while (*s1 && *s2 &&!(*s1 - *s2))
		{
			s1++;
			s2++;
		}
		if (!*s2)
			return cp;
		cp++;
	}
	return NULL;
}

union Un
{
	char c;
	int i;
};
union Un1
{
	char c[5];
	int i;
};
//int main()
//{
//	int str1[] = { 1,2,3,4,5,6,7,8,9 };
//
//	mymemove(str1 + 2, str1,20);
//	/*for (int i = 0; i < sizeof(str1)/sizeof(str1[0]); i++)
//	{
//		cout << str1[i] << " ";
//	}*/
//	cout << sizeof(i) << endl;
//	return 0;
//}
// 


#include <stdio.h>  

int check_endianness() {
	unsigned int num = 0x1; // 选择一个只有一个字节为1的数，例如0x00000001  
	char* byte = (char*)&num; // 将num的地址转换为char*，以便访问其第一个字节  

	// 如果*byte为1，则表示机器是小端存储，因为最低有效字节存储在最低地址  
	// 如果*byte为0，则表示机器是大端存储，因为最高有效字节（在这个例子中是唯一的非零字节）存储在更高地址  
	return *byte;
}

//int main() {
//	if (check_endianness()) {
//		printf("The machine is Little-endian.\n");
//	}
//	else {
//		printf("The machine is Big-endian.\n");
//	}
//	return 0;
//}

char* Mystrstr(const char* str1, const char* str2)
{
	if (!*str2)
		return (char*)str1;

	char* cp =(char*)str1;
	char* s1, * s2;

	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;
		while (*s1 && *s2 && !(*s1 - *s2))
		{
			s1++;
			s2++;
		}
		if (!*s2)
			return cp;
		cp++;
	}
	return NULL;
}



//#include <stdio.h>
//int main()
//{
//	char a = -1;
//	signed char b = -1;
//	unsigned char c = -1;
//	printf("a=%d,b=%d,c=%d", a, b, c);
//	return 0;
//}


#include <stdio.h>
//int main()
//{
//
//	unsigned int i;
//	for (i = 9; i >= 0; i--)
//	{
//		printf("%u\n", i);
//	}
//	return 0;
//}
/*

int main()
{
	int n = 9;
	float* pFloat = (float*)&n;
	printf("n的值为：%d\n", n);
	printf("*pFloat的值为：%f\n", *pFloat);
	*pFloat = 9.0;
	printf("num的值为：%d\n", n);
	printf("*pFloat的值为：%f\n", *pFloat);
	return 0;
}*/



//// 类中既有成员变量，又有成员函数
//class A1 {
//public:
//	void f1() {}
//private:
//	int _a;
//};
//class A2 {
//public:
//	void f2() {}
//};
//// 类中什么都没有---空类
//class A3
//{};
//
//
//int main()
//{
//	cout << sizeof(A1) << " " << sizeof(A2) << " " << sizeof(A3) << endl;
//	return 0 ;
//}




//// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
//class A
//{
//public:
//	void Print()
//	{
//		cout << "Print()" << endl;
//	}
//private:
//	int _a;
//};
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//	return 0;
//}
 //1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
//class A
//{
//public:
//	void PrintA()
//	{
//		cout << _a << endl;
//	}
//private:
//	int _a;
//};
//int main()
//{
//	A* p = nullptr;
//	p->PrintA();
//	return 0;
//}



//class Date
//{
//public:
//	/*Date()
//	{
//		_year = 1900;
//		_month = 1;
//		_day = 1;
//	}*/
//	Date(int year = 1900, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//// 以下测试函数能通过编译吗？
//void Test()
//{
//	Date d1;
//}


//int main()
//{
//	const int& a = 10;
//	return 0; 
//}

//
//void Fun(int& x) { cout << "左值引用" << endl; }
//void Fun(const int& x) { cout << "const 左值引用" << endl; }
//void Fun(int&& x) { cout << "右值引用" << endl; }
//void Fun(const int&& x) { cout << "const 右值引用" << endl; }
//// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
//// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
//// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
//// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
//template<typename T>
//void PerfectForward(T&& t)
//{
//	Fun(t);
//}
//int main()
//{
//	PerfectForward(10);// 右值
//	int a;
//	PerfectForward(a);// 左值
//	PerfectForward(std::move(a)); // 右值
//	const int b = 8;
//	PerfectForward(b);// const 左值
//	PerfectForward(std::move(b)); // const 右值
//	return 0;
//}



#include <chrono>
#include <functional>
#include <future>
#include <iostream>
#include <string>

//#include <chrono>
//#include <functional>
//#include <future>
//#include <iostream>
//#include <string>
//
//class A {
//public:
//	A() {
//		std::cout << "A() \n";
//	}
//
//	~A() {
//		std::cout << "~A() \n";
//	}
//
//	A(const A& a) {
//		count_ = a.count_;
//		std::cout << "A copy \n";
//	}
//
//	A& operator=(const A& a) {
//		count_ = a.count_;
//		std::cout << "A = \n";
//		return *this;
//	}
//
//	A(A&& a) {
//		count_ = std::move(a.count_);
//		std::cout << "A move \n";
//	}
//
//	A& operator=(A&& a) {
//		count_ = std::move(a.count_);
//		std::cout << "A move = \n";
//		return *this;
//	}
//
//	std::string count_;
//};
//
//
//int main() {
//	A a;
//	a.count_ = "12345";
//	A b = std::move(a);
//	std::cout << a.count_ << std::endl;
//	std::cout << b.count_ << std::endl;
//	return 0;
//}



//struct ListNode
//{
//	int _data;
//	shared_ptr<ListNode> _prev;
//	shared_ptr<ListNode> _next;
//	~ListNode() 
//	{ 
//		cout << "~ListNode()" << endl; 
//	}
//};
//int main()
//{
//	shared_ptr<ListNode> node1(new ListNode);
//	shared_ptr<ListNode> node2(new ListNode);
//	cout << node1.use_count() << endl;
//	cout << node2.use_count() << endl;
//	node1->_next = node2;
//	node2->_prev = node1;
//	cout << node1.use_count() << endl;
//	cout << node2.use_count() << endl;
//	return 0;
//}


//
//
//class Person
//{
//protected:
//	string _name = "小李子"; // 姓名
//	int _num = 111; 
//};
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << " 姓名:" << _name << endl;
//		cout << " 身份证号:" << Person::_num << endl;
//		cout << " 学号:" << _num << endl;
//	}
//protected:
//	int _num = 999; // 学号
//};
//void Test()
//{
//	Student s1;
//	s1.Print();
//};
//
//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		A::fun();
//		cout << "func(int i)->" << i << endl;
//	}
//};
//void Test()
//{
// B b;
// b.fun(10);
//};


//
//
//class Person
//{
//public:
//	Person(const char* name = "peter")
//		: _name(name)
//	{
//		cout << "Person()" << endl;
//	}
//
//	Person(const Person& p)
//		: _name(p._name)
//	{
//			cout << "Person(const Person& p)" << endl;
//	}
//
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//
//		return *this;
//	}
//
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name; // 姓名
//};
//
//class Student : public Person
//{
//public:
//	Student(const char* name, int num)
//		: Person(name)
//		, _num(num)
//	{
//		cout << "Student()" << endl;
//	}
//
//	Student(const Student& s)
//		: Person(s)
//		, _num(s._num)
//	{
//		cout << "Student(const Student& s)" << endl;
//	}
//
//	Student& operator = (const Student& s)
//	{
//		cout << "Student& operator= (const Student& s)" << endl;
//		if (this != &s)
//		{
//			Person::operator =(s);
//			_num = s._num;
//		}
//		return *this;
//	}
//
//	~Student()
//	{
//		cout << "~Student()" << endl;
//	}
//protected:
//	int _num; //学号
//};
//
//void Test()
//{
//	Student s1("jack", 18);
//	Student s2(s1);
//	Student s3("rose", 17);
//	s1 = s3;
//}
//int main()
//{
//	Test();
//	return 0;
//}




//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//protected:
//	int _stuNum; // 学号
//};
//
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}



//class Person
//{
//public:
//	Person() { ++_count; }
//protected:
//	string _name; // 姓名
//public:
//	static int _count; // 统计人的个数。
//};
//
//int Person::_count = 0;
//
//class Student : public Person
//{
//protected:
//	int _stuNum; // 学号
//};
//
//class Graduate : public Student
//{
//protected:
// string _seminarCourse; // 研究科目
//};
//
//void TestPerson()
//{
//	Student s1;
//	Student s2;
//	Student s3;
//	Graduate s4;
//	cout << " 人数 :" << Person::_count << endl;
//	Student::_count = 0;
//	cout << " 人数 :" << Person::_count << endl;
//}
//
//void main()
//{
//	TestPerson();
//}




//
//class Person
//{
//public:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//protected:
//	int _num; //学号
//};
//class Teacher : public Person
//{
//protected:
//	int _id; // 职工编号
//};
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
//
//void Test()
//{
//	// 这样会有二义性无法明确知道访问的是哪一个
//	Assistant a;
//	a._name = "peter";
//	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
//	a.Student::_name = "xxx";
//	a.Teacher::_name = "yyy";
//}
//
//void main()
//{
//	Test();
//}



//
//class Person {
//public:
//	virtual void BuyTicket() 
//	{ 
//		cout << "买票-全价" << endl; 
//	}
//};
//
//class Student : public Person {
//public:
//	virtual void BuyTicket() { cout << "买票-半价" << endl; }
//};
//
//void Func(Person& p)
//{ 
//	p.BuyTicket(); 
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//	Func(ps);
//	Func(st);
//	return 0;
//}


//
//class Car
//{
//public:
//	virtual void Drive() = 0;
//};
//
//class Benz :public Car
//{
//public:
//	virtual void Drive()
//	{
//		cout << "Benz-舒适" << endl;
//	}
//};
//
//class BMW :public Car
//{
//public:
//	virtual void Drive()
//	{
//		cout << "BMW-操控" << endl;
//	}
//};
//
//void Test()
//{
//	Car* pBenz = new Benz;
//	pBenz->Drive();
//	Car* pBMW = new BMW;
//	pBMW->Drive();
//}
//
//
//void main()
//{
//	Test();
//}
//
//
//
//class Base
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Base::Func1()" << endl;
//	}
//	virtual void Func2()
//	{
//		cout << "Base::Func2()" << endl;
//	}
//	void Func3()
//	{
//		cout << "Base::Func3()" << endl;
//	}
//private:
//	int _b = 1;
//};
//
//
//class Derive : public Base
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Derive::Func1()" << endl;
//	}
//private:
//	int _d = 2;
//};
//
//
//int main()
//{
//	Base b;
//	Derive d;
//	return 0;
//}


//
//#include<iostream>
//	using namespace std;
//
//class A {
//public:
//	A(char* s) { cout << s << endl; }
//	~A() {}
//};
//
//class B :virtual public A
//{
//public:
//	B(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
//};
//
//
//class C :virtual public A
//{
//public:
//	C(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
//};
//
//
//
//class D :public B, public C
//{
//public:
//	D(char* s1, char* s2, char* s3, char* s4) 
//		:B(s1, s2), 
//		C(s1, s3), 
//		A(s1)
//	{
//		cout << s4 << endl;
//	}
//};
//
//
//
//int main() {
//	D* p = new D("class A", "class B", "class C", "class D");
//	delete p;
//	return 0;
//}
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3
//class Base1 { public:  int _b1; };
//class Base2 { public:  int _b2; };
//					class Derive : public Base1, public Base2 { public: int _d; };
//					int main() {
//						Derive d;
//						Base1* p1 = &d;
//						Base2* p2 = &d;
//						Derive* p3 = &d;
//						return 0;
					//}


#include <utility>


class A
{
public:
	virtual void func(int val = 1) 
	{ 
		std::cout << "A->" << val << std::endl; 
	}
	virtual void test() { func(); }
};

class B : public A
{
public:
	void func(int val = 0) 
	{ 
		std::cout << "B->" << val << std::endl; 
	}
};


void BubbleSort(int* a, int size)
{
	for (int i = 0; i < size - 1; i++)
	{
		for (int j = 1; j < size - i; j++)
		{
			if (a[j - 1] > a[j])
			{
				swap(a[j - 1], a[j]);
			}
		}
	}
}

int main()
{
	int arr[7] = { 5,9,31,1,0,51,-1 };
	BubbleSort(arr, 7);
	for (int i = 0; i < 7; i++)
	{
		cout << arr[i] << " ";
	}
	return 0;
}